home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  48.3 KB  |  1,707 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Quickdraw;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __QUICKDRAW__}
  27. {$SETC __QUICKDRAW__ := 1}
  28.  
  29. {$I+}
  30. {$SETC QuickdrawIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  44. {$I QuickdrawText.p}
  45. {$ENDC}
  46.  
  47. {$PUSH}
  48. {$ALIGN MAC68K}
  49. {$LibExport+}
  50.  
  51. CONST
  52.     invalColReq                    = -1;                            {invalid color table request}
  53. { transfer modes }
  54.     srcCopy                        = 0;                            {the 16 transfer modes}
  55.     srcOr                        = 1;
  56.     srcXor                        = 2;
  57.     srcBic                        = 3;
  58.     notSrcCopy                    = 4;
  59.     notSrcOr                    = 5;
  60.     notSrcXor                    = 6;
  61.     notSrcBic                    = 7;
  62.     patCopy                        = 8;
  63.     patOr                        = 9;
  64.     patXor                        = 10;
  65.     patBic                        = 11;
  66.     notPatCopy                    = 12;
  67.     notPatOr                    = 13;
  68.     notPatXor                    = 14;
  69.     notPatBic                    = 15;
  70. { Special Text Transfer Mode }
  71.     grayishTextOr                = 49;
  72. { Arithmetic transfer modes }
  73.     blend                        = 32;
  74.     addPin                        = 33;
  75.  
  76.     addOver                        = 34;
  77.     subPin                        = 35;
  78.     addMax                        = 37;
  79.     adMax                        = 37;
  80.     subOver                        = 38;
  81.     adMin                        = 39;
  82.     ditherCopy                    = 64;
  83. { Transparent mode constant }
  84.     transparent                    = 36;
  85. { QuickDraw color separation constants }
  86.     normalBit                    = 0;                            {normal screen mapping}
  87.     inverseBit                    = 1;                            {inverse screen mapping}
  88.     redBit                        = 4;                            {RGB additive mapping}
  89.     greenBit                    = 3;
  90.     blueBit                        = 2;
  91.     cyanBit                        = 8;                            {CMYBk subtractive mapping}
  92.     magentaBit                    = 7;
  93.     yellowBit                    = 6;
  94.     blackBit                    = 5;
  95.     blackColor                    = 33;                            {colors expressed in these mappings}
  96.     whiteColor                    = 30;
  97.     redColor                    = 205;
  98.  
  99.     greenColor                    = 341;
  100.     blueColor                    = 409;
  101.     cyanColor                    = 273;
  102.     magentaColor                = 137;
  103.     yellowColor                    = 69;
  104.     picLParen                    = 0;                            {standard picture comments}
  105.     picRParen                    = 1;
  106.     clutType                    = 0;                            {0 if lookup table}
  107.     fixedType                    = 1;                            {1 if fixed table}
  108.     directType                    = 2;                            {2 if direct values}
  109.     gdDevType                    = 0;                            {0 = monochrome 1 = color}
  110.  
  111.     roundedDevice                = 5;                            { 1 if device has been “rounded” into the GrayRgn }
  112.     hasAuxMenuBar                = 6;                            { 1 if device has an aux menu bar on it }
  113.     burstDevice                    = 7;
  114.     ext32Device                    = 8;
  115.     ramInit                        = 10;                            {1 if initialized from 'scrn' resource}
  116.     mainScreen                    = 11;                            { 1 if main screen }
  117.     allInit                        = 12;                            { 1 if all devices initialized }
  118.     screenDevice                = 13;                            {1 if screen device [not used]}
  119.     noDriver                    = 14;                            { 1 if no driver for this GDevice }
  120.     screenActive                = 15;                            {1 if in use}
  121.     hiliteBit                    = 7;                            {flag bit in HiliteMode (lowMem flag)}
  122.     pHiliteBit                    = 0;                            {flag bit in HiliteMode used with BitClr procedure}
  123.     defQDColors                    = 127;                            {resource ID of clut for default QDColors}
  124. { pixel type }
  125.     RGBDirect                    = 16;                            { 16 & 32 bits/pixel pixelType value }
  126. { pmVersion values }
  127.     baseAddr32                    = 4;                            {pixmap base address is 32-bit address}
  128.  
  129.     frame                        = 0;
  130.     paint                        = 1;
  131.     erase                        = 2;
  132.     invert                        = 3;
  133.     fill                        = 4;
  134.  
  135.     
  136. TYPE
  137.     GrafVerb = SInt8;
  138.  
  139.  
  140. CONST
  141.     chunky                        = 0;
  142.     chunkyPlanar                = 1;
  143.     planar                        = 2;
  144.  
  145.     
  146. TYPE
  147.     PixelType = SInt8;
  148.  
  149.     Bits16 = ARRAY [0..15] OF INTEGER;
  150.  
  151. {**************   IMPORTANT NOTE REGARDING Pattern  **************************************
  152.    Patterns were originally defined as:
  153.    
  154.         C:             typedef unsigned char Pattern[8];
  155.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  156.         
  157.    The old array defintion of Pattern would cause 68000 based CPU's to crash in certain circum-
  158.    stances. The new struct definition is safe, but may require source code changes to compile.
  159.    Read the details in TechNote "Platforms & Tools" #PT 38.
  160.     
  161. ********************************************************************************************}
  162.     Pattern = RECORD
  163.         pat:                    PACKED ARRAY [0..7] OF SInt8;
  164.     END;
  165.     ConstPatternParam = Pattern;
  166.  
  167.     PatPtr = ^Pattern;
  168.  
  169.     PatHandle = ^PatPtr;
  170.  
  171.     QDByte = SignedByte;
  172.  
  173.     QDPtr = Ptr;
  174.  
  175.     QDHandle = Handle;
  176.  
  177.     QDErr = INTEGER;
  178.  
  179.  
  180. CONST
  181.     singleDevicesBit            = 0;
  182.     dontMatchSeedsBit            = 1;
  183.     allDevicesBit                = 2;
  184.  
  185.     singleDevices                = 1 * (2**(singleDevicesBit));
  186.     dontMatchSeeds                = 1 * (2**(dontMatchSeedsBit));
  187.     allDevices                    = 1 * (2**(allDevicesBit));
  188.  
  189.     
  190. TYPE
  191.     DeviceLoopFlags = LONGINT;
  192.  
  193.     BitMap = RECORD
  194.         baseAddr:                Ptr;
  195.         rowBytes:                INTEGER;
  196.         bounds:                    Rect;
  197.     END;
  198.     BitMapPtr = ^BitMap;
  199.     BitMapHandle = ^BitMapPtr;
  200.  
  201.     Cursor = RECORD
  202.         data:                    Bits16;
  203.         mask:                    Bits16;
  204.         hotSpot:                Point;
  205.     END;
  206.     CursPtr = ^Cursor;
  207.     CursHandle = ^CursPtr;
  208.  
  209.     PenState = RECORD
  210.         pnLoc:                    Point;
  211.         pnSize:                    Point;
  212.         pnMode:                    INTEGER;
  213.         pnPat:                    Pattern;
  214.     END;
  215.     Region = RECORD
  216.         rgnSize:                INTEGER;                                {size in bytes}
  217.         rgnBBox:                Rect;                                    {enclosing rectangle}
  218.     END;
  219.     RgnPtr = ^Region;
  220.     RgnHandle = ^RgnPtr;
  221.  
  222.     Picture = RECORD
  223.         picSize:                INTEGER;
  224.         picFrame:                Rect;
  225.     END;
  226.     PicPtr = ^Picture;
  227.     PicHandle = ^PicPtr;
  228.  
  229.     Polygon = RECORD
  230.         polySize:                INTEGER;
  231.         polyBBox:                Rect;
  232.         polyPoints:                ARRAY [0..0] OF Point;
  233.     END;
  234.     PolyPtr = ^Polygon;
  235.     PolyHandle = ^PolyPtr;
  236.  
  237.     QDTextProcPtr = ProcPtr;  { PROCEDURE QDText(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point); }
  238.     QDLineProcPtr = ProcPtr;  { PROCEDURE QDLine(newPt: Point); }
  239.     QDRectProcPtr = ProcPtr;  { PROCEDURE QDRect(verb: ByteParameter; VAR r: Rect); }
  240.     QDRRectProcPtr = ProcPtr;  { PROCEDURE QDRRect(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER); }
  241.     QDOvalProcPtr = ProcPtr;  { PROCEDURE QDOval(verb: ByteParameter; VAR r: Rect); }
  242.     QDArcProcPtr = ProcPtr;  { PROCEDURE QDArc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER); }
  243.     QDPolyProcPtr = ProcPtr;  { PROCEDURE QDPoly(verb: ByteParameter; poly: PolyHandle); }
  244.     QDRgnProcPtr = ProcPtr;  { PROCEDURE QDRgn(verb: ByteParameter; rgn: RgnHandle); }
  245.     QDBitsProcPtr = ProcPtr;  { PROCEDURE QDBits(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle); }
  246.     QDCommentProcPtr = ProcPtr;  { PROCEDURE QDComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle); }
  247.     QDTxMeasProcPtr = ProcPtr;  { FUNCTION QDTxMeas(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER; }
  248.     QDGetPicProcPtr = ProcPtr;  { PROCEDURE QDGetPic(dataPtr: Ptr; byteCount: INTEGER); }
  249.     QDPutPicProcPtr = ProcPtr;  { PROCEDURE QDPutPic(dataPtr: Ptr; byteCount: INTEGER); }
  250.     QDOpcodeProcPtr = ProcPtr;  { PROCEDURE QDOpcode(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER); }
  251.     QDJShieldCursorProcPtr = ProcPtr;  { PROCEDURE QDJShieldCursor(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER); }
  252.     QDTextUPP = UniversalProcPtr;
  253.     QDLineUPP = UniversalProcPtr;
  254.     QDRectUPP = UniversalProcPtr;
  255.     QDRRectUPP = UniversalProcPtr;
  256.     QDOvalUPP = UniversalProcPtr;
  257.     QDArcUPP = UniversalProcPtr;
  258.     QDPolyUPP = UniversalProcPtr;
  259.     QDRgnUPP = UniversalProcPtr;
  260.     QDBitsUPP = UniversalProcPtr;
  261.     QDCommentUPP = UniversalProcPtr;
  262.     QDTxMeasUPP = UniversalProcPtr;
  263.     QDGetPicUPP = UniversalProcPtr;
  264.     QDPutPicUPP = UniversalProcPtr;
  265.     QDOpcodeUPP = UniversalProcPtr;
  266.     QDJShieldCursorUPP = UniversalProcPtr;
  267.  
  268.     QDProcs = RECORD
  269.         textProc:                QDTextUPP;
  270.         lineProc:                QDLineUPP;
  271.         rectProc:                QDRectUPP;
  272.         rRectProc:                QDRRectUPP;
  273.         ovalProc:                QDOvalUPP;
  274.         arcProc:                QDArcUPP;
  275.         polyProc:                QDPolyUPP;
  276.         rgnProc:                QDRgnUPP;
  277.         bitsProc:                QDBitsUPP;
  278.         commentProc:            QDCommentUPP;
  279.         txMeasProc:                QDTxMeasUPP;
  280.         getPicProc:                QDGetPicUPP;
  281.         putPicProc:                QDPutPicUPP;
  282.     END;
  283.     QDProcsPtr = ^QDProcs;
  284.  
  285. CONST
  286.     uppQDTextProcInfo = $00003F80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param); }
  287.     uppQDLineProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  288.     uppQDRectProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  289.     uppQDRRectProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  290.     uppQDOvalProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  291.     uppQDArcProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  292.     uppQDPolyProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  293.     uppQDRgnProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  294.     uppQDBitsProcInfo = $0000EFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  295.     uppQDCommentProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  296.     uppQDTxMeasProcInfo = $0000FFA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  297.     uppQDGetPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  298.     uppQDPutPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  299.     uppQDOpcodeProcInfo = $00002BC0; { PROCEDURE (4 byte param, 4 byte param, 2 byte param, 2 byte param); }
  300.     uppQDJShieldCursorProcInfo = $00002A80; { PROCEDURE (2 byte param, 2 byte param, 2 byte param, 2 byte param); }
  301.  
  302. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  303.     {$IFC NOT GENERATINGCFM }
  304.     INLINE $2E9F;
  305.     {$ENDC}
  306.  
  307. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  308.     {$IFC NOT GENERATINGCFM }
  309.     INLINE $2E9F;
  310.     {$ENDC}
  311.  
  312. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  313.     {$IFC NOT GENERATINGCFM }
  314.     INLINE $2E9F;
  315.     {$ENDC}
  316.  
  317. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  318.     {$IFC NOT GENERATINGCFM }
  319.     INLINE $2E9F;
  320.     {$ENDC}
  321.  
  322. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  323.     {$IFC NOT GENERATINGCFM }
  324.     INLINE $2E9F;
  325.     {$ENDC}
  326.  
  327. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  328.     {$IFC NOT GENERATINGCFM }
  329.     INLINE $2E9F;
  330.     {$ENDC}
  331.  
  332. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  333.     {$IFC NOT GENERATINGCFM }
  334.     INLINE $2E9F;
  335.     {$ENDC}
  336.  
  337. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  338.     {$IFC NOT GENERATINGCFM }
  339.     INLINE $2E9F;
  340.     {$ENDC}
  341.  
  342. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  343.     {$IFC NOT GENERATINGCFM }
  344.     INLINE $2E9F;
  345.     {$ENDC}
  346.  
  347. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  348.     {$IFC NOT GENERATINGCFM }
  349.     INLINE $2E9F;
  350.     {$ENDC}
  351.  
  352. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  353.     {$IFC NOT GENERATINGCFM }
  354.     INLINE $2E9F;
  355.     {$ENDC}
  356.  
  357. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  358.     {$IFC NOT GENERATINGCFM }
  359.     INLINE $2E9F;
  360.     {$ENDC}
  361.  
  362. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  363.     {$IFC NOT GENERATINGCFM }
  364.     INLINE $2E9F;
  365.     {$ENDC}
  366.  
  367. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  368.     {$IFC NOT GENERATINGCFM }
  369.     INLINE $2E9F;
  370.     {$ENDC}
  371.  
  372. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  373.     {$IFC NOT GENERATINGCFM }
  374.     INLINE $2E9F;
  375.     {$ENDC}
  376.  
  377. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  378.     {$IFC NOT GENERATINGCFM}
  379.     INLINE $205F, $4E90;
  380.     {$ENDC}
  381.  
  382. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $205F, $4E90;
  385.     {$ENDC}
  386.  
  387. PROCEDURE CallQDRectProc(verb: ByteParameter; VAR r: Rect; userRoutine: QDRectUPP);
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $205F, $4E90;
  390.     {$ENDC}
  391.  
  392. PROCEDURE CallQDRRectProc(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  393.     {$IFC NOT GENERATINGCFM}
  394.     INLINE $205F, $4E90;
  395.     {$ENDC}
  396.  
  397. PROCEDURE CallQDOvalProc(verb: ByteParameter; VAR r: Rect; userRoutine: QDOvalUPP);
  398.     {$IFC NOT GENERATINGCFM}
  399.     INLINE $205F, $4E90;
  400.     {$ENDC}
  401.  
  402. PROCEDURE CallQDArcProc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  403.     {$IFC NOT GENERATINGCFM}
  404.     INLINE $205F, $4E90;
  405.     {$ENDC}
  406.  
  407. PROCEDURE CallQDPolyProc(verb: ByteParameter; poly: PolyHandle; userRoutine: QDPolyUPP);
  408.     {$IFC NOT GENERATINGCFM}
  409.     INLINE $205F, $4E90;
  410.     {$ENDC}
  411.  
  412. PROCEDURE CallQDRgnProc(verb: ByteParameter; rgn: RgnHandle; userRoutine: QDRgnUPP);
  413.     {$IFC NOT GENERATINGCFM}
  414.     INLINE $205F, $4E90;
  415.     {$ENDC}
  416.  
  417. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  418.     {$IFC NOT GENERATINGCFM}
  419.     INLINE $205F, $4E90;
  420.     {$ENDC}
  421.  
  422. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $205F, $4E90;
  425.     {$ENDC}
  426.  
  427. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  428.     {$IFC NOT GENERATINGCFM}
  429.     INLINE $205F, $4E90;
  430.     {$ENDC}
  431.  
  432. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  433.     {$IFC NOT GENERATINGCFM}
  434.     INLINE $205F, $4E90;
  435.     {$ENDC}
  436.  
  437. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  438.     {$IFC NOT GENERATINGCFM}
  439.     INLINE $205F, $4E90;
  440.     {$ENDC}
  441.  
  442. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  443.     {$IFC NOT GENERATINGCFM}
  444.     INLINE $205F, $4E90;
  445.     {$ENDC}
  446.  
  447. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  448.     {$IFC NOT GENERATINGCFM}
  449.     INLINE $205F, $4E90;
  450.     {$ENDC}
  451.  
  452. TYPE
  453.     GrafPort = RECORD
  454.         device:                    INTEGER;
  455.         portBits:                BitMap;
  456.         portRect:                Rect;
  457.         visRgn:                    RgnHandle;
  458.         clipRgn:                RgnHandle;
  459.         bkPat:                    Pattern;
  460.         fillPat:                Pattern;
  461.         pnLoc:                    Point;
  462.         pnSize:                    Point;
  463.         pnMode:                    INTEGER;
  464.         pnPat:                    Pattern;
  465.         pnVis:                    INTEGER;
  466.         txFont:                    INTEGER;
  467.         txFace:                    Style;                                    {txFace is unpacked byte but push as short}
  468.         txMode:                    INTEGER;
  469.         txSize:                    INTEGER;
  470.         spExtra:                Fixed;
  471.         fgColor:                LONGINT;
  472.         bkColor:                LONGINT;
  473.         colrBit:                INTEGER;
  474.         patStretch:                INTEGER;
  475.         picSave:                Handle;
  476.         rgnSave:                Handle;
  477.         polySave:                Handle;
  478.         grafProcs:                QDProcsPtr;
  479.     END;
  480.     GrafPtr = ^GrafPort;
  481.  
  482. {
  483.  *    This set of definitions "belongs" in Windows.
  484.  *    But, there is a circularity in the headers where Windows includes Controls and
  485.  *    Controls includes Windows. To break the circle, the information
  486.  *    needed by Controls is moved from Windows to Quickdraw.
  487.  }
  488.     WindowPtr = GrafPtr;
  489.  
  490. {
  491.     Set STRICT_WINDOWS to 1 to make sure your code 
  492.     doesn't access the window record directly
  493. }
  494. {$IFC UNDEFINED STRICT_WINDOWS }
  495. {$SETC STRICT_WINDOWS := 0}
  496. {$ENDC}
  497. {$IFC STRICT_WINDOWS }
  498.     WindowRef = Ptr;
  499.  
  500. {$ELSEC}
  501.     WindowRef = WindowPtr;
  502.  
  503. {$ENDC}
  504.     DragConstraint = UInt16;
  505.  
  506.  
  507. CONST
  508.     kNoConstraint                = 0;
  509.     kVerticalConstraint            = 1;
  510.     kHorizontalConstraint        = 2;
  511.  
  512. {
  513.  *    Here ends the list of things that "belong" in Windows.
  514.  }
  515.  
  516. TYPE
  517.     RGBColor = RECORD
  518.         red:                    INTEGER;                                {magnitude of red component}
  519.         green:                    INTEGER;                                {magnitude of green component}
  520.         blue:                    INTEGER;                                {magnitude of blue component}
  521.     END;
  522.     RGBColorPtr = ^RGBColor;
  523.     RGBColorHdl = ^RGBColorPtr;
  524.  
  525.     DragGrayRgnProcPtr = ProcPtr;  { PROCEDURE DragGrayRgn; }
  526.     ColorSearchProcPtr = ProcPtr;  { FUNCTION ColorSearch(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN; }
  527.     ColorComplementProcPtr = ProcPtr;  { FUNCTION ColorComplement(VAR rgb: RGBColor): BOOLEAN; }
  528.     DragGrayRgnUPP = UniversalProcPtr;
  529.     ColorSearchUPP = UniversalProcPtr;
  530.     ColorComplementUPP = UniversalProcPtr;
  531.  
  532. CONST
  533.     uppDragGrayRgnProcInfo = $00000000; { PROCEDURE ; }
  534.     uppColorSearchProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  535.     uppColorComplementProcInfo = $000000D0; { FUNCTION (4 byte param): 1 byte result; }
  536.  
  537. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  538.     {$IFC NOT GENERATINGCFM }
  539.     INLINE $2E9F;
  540.     {$ENDC}
  541.  
  542. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  543.     {$IFC NOT GENERATINGCFM }
  544.     INLINE $2E9F;
  545.     {$ENDC}
  546.  
  547. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  548.     {$IFC NOT GENERATINGCFM }
  549.     INLINE $2E9F;
  550.     {$ENDC}
  551.  
  552. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  553.     {$IFC NOT GENERATINGCFM}
  554.     INLINE $205F, $4E90;
  555.     {$ENDC}
  556.  
  557. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  558.     {$IFC NOT GENERATINGCFM}
  559.     INLINE $205F, $4E90;
  560.     {$ENDC}
  561.  
  562. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $205F, $4E90;
  565.     {$ENDC}
  566.  
  567. TYPE
  568.     ColorSpec = RECORD
  569.         value:                    INTEGER;                                {index or other value}
  570.         rgb:                    RGBColor;                                {true color}
  571.     END;
  572.     ColorSpecPtr = ^ColorSpec;
  573.  
  574.     CSpecArray = ARRAY [0..0] OF ColorSpec;
  575.  
  576.     ColorTable = RECORD
  577.         ctSeed:                    LONGINT;                                {unique identifier for table}
  578.         ctFlags:                INTEGER;                                {high bit: 0 = PixMap; 1 = device}
  579.         ctSize:                    INTEGER;                                {number of entries in CTTable}
  580.         ctTable:                CSpecArray;                                {array [0..0] of ColorSpec}
  581.     END;
  582.     CTabPtr = ^ColorTable;
  583.     CTabHandle = ^CTabPtr;
  584.  
  585.     MatchRec = RECORD
  586.         red:                    INTEGER;
  587.         green:                    INTEGER;
  588.         blue:                    INTEGER;
  589.         matchData:                LONGINT;
  590.     END;
  591.     PixMap = RECORD
  592.         baseAddr:                Ptr;                                    {pointer to pixels}
  593.         rowBytes:                INTEGER;                                {offset to next line}
  594.         bounds:                    Rect;                                    {encloses bitmap}
  595.         pmVersion:                INTEGER;                                {pixMap version number}
  596.         packType:                INTEGER;                                {defines packing format}
  597.         packSize:                LONGINT;                                {length of pixel data}
  598.         hRes:                    Fixed;                                    {horiz. resolution (ppi)}
  599.         vRes:                    Fixed;                                    {vert. resolution (ppi)}
  600.         pixelType:                INTEGER;                                {defines pixel type}
  601.         pixelSize:                INTEGER;                                {# bits in pixel}
  602.         cmpCount:                INTEGER;                                {# components in pixel}
  603.         cmpSize:                INTEGER;                                {# bits per component}
  604.         planeBytes:                LONGINT;                                {offset to next plane}
  605.         pmTable:                CTabHandle;                                {color map for this pixMap}
  606.         pmReserved:                LONGINT;                                {for future use. MUST BE 0}
  607.     END;
  608.     PixMapPtr = ^PixMap;
  609.     PixMapHandle = ^PixMapPtr;
  610.  
  611.     PixPat = RECORD
  612.         patType:                INTEGER;                                {type of pattern}
  613.         patMap:                    PixMapHandle;                            {the pattern's pixMap}
  614.         patData:                Handle;                                    {pixmap's data}
  615.         patXData:                Handle;                                    {expanded Pattern data}
  616.         patXValid:                INTEGER;                                {flags whether expanded Pattern valid}
  617.         patXMap:                Handle;                                    {Handle to expanded Pattern data}
  618.         pat1Data:                Pattern;                                {old-Style pattern/RGB color}
  619.     END;
  620.     PixPatPtr = ^PixPat;
  621.     PixPatHandle = ^PixPatPtr;
  622.  
  623.     CCrsr = RECORD
  624.         crsrType:                INTEGER;                                {type of cursor}
  625.         crsrMap:                PixMapHandle;                            {the cursor's pixmap}
  626.         crsrData:                Handle;                                    {cursor's data}
  627.         crsrXData:                Handle;                                    {expanded cursor data}
  628.         crsrXValid:                INTEGER;                                {depth of expanded data (0 if none)}
  629.         crsrXHandle:            Handle;                                    {future use}
  630.         crsr1Data:                Bits16;                                    {one-bit cursor}
  631.         crsrMask:                Bits16;                                    {cursor's mask}
  632.         crsrHotSpot:            Point;                                    {cursor's hotspot}
  633.         crsrXTable:                LONGINT;                                {private}
  634.         crsrID:                    LONGINT;                                {private}
  635.     END;
  636.     CCrsrPtr = ^CCrsr;
  637.     CCrsrHandle = ^CCrsrPtr;
  638.  
  639. {$IFC OLDROUTINELOCATIONS }
  640.     CIcon = RECORD
  641.         iconPMap:                PixMap;                                    {the icon's pixMap}
  642.         iconMask:                BitMap;                                    {the icon's mask}
  643.         iconBMap:                BitMap;                                    {the icon's bitMap}
  644.         iconData:                Handle;                                    {the icon's data}
  645.         iconMaskData:            ARRAY [0..0] OF INTEGER;                {icon's mask and BitMap data}
  646.     END;
  647.     CIconPtr = ^CIcon;
  648.     CIconHandle = ^CIconPtr;
  649.  
  650. {$ENDC}
  651.     GammaTbl = RECORD
  652.         gVersion:                INTEGER;                                {gamma version number}
  653.         gType:                    INTEGER;                                {gamma data type}
  654.         gFormulaSize:            INTEGER;                                {Formula data size}
  655.         gChanCnt:                INTEGER;                                {number of channels of data}
  656.         gDataCnt:                INTEGER;                                {number of values/channel}
  657.         gDataWidth:                INTEGER;                                {bits/corrected value (data packed to next larger byte size)}
  658.         gFormulaData:            ARRAY [0..0] OF INTEGER;                {data for formulas followed by gamma values}
  659.     END;
  660.     GammaTblPtr = ^GammaTbl;
  661.     GammaTblHandle = ^GammaTblPtr;
  662.  
  663.     ITab = RECORD
  664.         iTabSeed:                LONGINT;                                {copy of CTSeed from source CTable}
  665.         iTabRes:                INTEGER;                                {bits/channel resolution of iTable}
  666.         iTTable:                ARRAY [0..0] OF SInt8;                    {byte colortable index values}
  667.     END;
  668.     ITabPtr = ^ITab;
  669.     ITabHandle = ^ITabPtr;
  670.  
  671.     SProcRec = RECORD
  672.         nxtSrch:                Handle;                                    {SProcHndl Handle to next SProcRec}
  673.         srchProc:                ColorSearchUPP;                            {search procedure proc ptr}
  674.     END;
  675.     SProcPtr = ^SProcRec;
  676.     SProcHndl = ^SProcPtr;
  677.  
  678.     CProcRec = RECORD
  679.         nxtComp:                Handle;                                    {CProcHndl Handle to next CProcRec}
  680.         compProc:                ColorComplementUPP;                        {complement procedure proc ptr}
  681.     END;
  682.     CProcPtr = ^CProcRec;
  683.     CProcHndl = ^CProcPtr;
  684.  
  685.     GDevice = RECORD
  686.         gdRefNum:                INTEGER;                                {driver's unit number}
  687.         gdID:                    INTEGER;                                {client ID for search procs}
  688.         gdType:                    INTEGER;                                {fixed/CLUT/direct}
  689.         gdITable:                ITabHandle;                                {Handle to inverse lookup table}
  690.         gdResPref:                INTEGER;                                {preferred resolution of GDITable}
  691.         gdSearchProc:            SProcHndl;                                {search proc list head}
  692.         gdCompProc:                CProcHndl;                                {complement proc list}
  693.         gdFlags:                INTEGER;                                {grafDevice flags word}
  694.         gdPMap:                    PixMapHandle;                            {describing pixMap}
  695.         gdRefCon:                LONGINT;                                {reference value}
  696.         gdNextGD:                Handle;                                    {GDHandle Handle of next gDevice}
  697.         gdRect:                    Rect;                                    { device's bounds in global coordinates}
  698.         gdMode:                    LONGINT;                                {device's current mode}
  699.         gdCCBytes:                INTEGER;                                {depth of expanded cursor data}
  700.         gdCCDepth:                INTEGER;                                {depth of expanded cursor data}
  701.         gdCCXData:                Handle;                                    {Handle to cursor's expanded data}
  702.         gdCCXMask:                Handle;                                    {Handle to cursor's expanded mask}
  703.         gdReserved:                LONGINT;                                {future use. MUST BE 0}
  704.     END;
  705.     GDPtr = ^GDevice;
  706.     GDHandle = ^GDPtr;
  707.  
  708.     GrafVars = RECORD
  709.         rgbOpColor:                RGBColor;                                {color for addPin  subPin and average}
  710.         rgbHiliteColor:            RGBColor;                                {color for hiliting}
  711.         pmFgColor:                Handle;                                    {palette Handle for foreground color}
  712.         pmFgIndex:                INTEGER;                                {index value for foreground}
  713.         pmBkColor:                Handle;                                    {palette Handle for background color}
  714.         pmBkIndex:                INTEGER;                                {index value for background}
  715.         pmFlags:                INTEGER;                                {flags for Palette Manager}
  716.     END;
  717.     GVarPtr = ^GrafVars;
  718.     GVarHandle = ^GVarPtr;
  719.  
  720.     CQDProcs = RECORD
  721.         textProc:                QDTextUPP;
  722.         lineProc:                QDLineUPP;
  723.         rectProc:                QDRectUPP;
  724.         rRectProc:                QDRRectUPP;
  725.         ovalProc:                QDOvalUPP;
  726.         arcProc:                QDArcUPP;
  727.         polyProc:                QDPolyUPP;
  728.         rgnProc:                QDRgnUPP;
  729.         bitsProc:                QDBitsUPP;
  730.         commentProc:            QDCommentUPP;
  731.         txMeasProc:                QDTxMeasUPP;
  732.         getPicProc:                QDGetPicUPP;
  733.         putPicProc:                QDPutPicUPP;
  734.         opcodeProc:                QDOpcodeUPP;                            {fields added to QDProcs}
  735.         newProc1:                UniversalProcPtr;
  736.         newProc2:                UniversalProcPtr;
  737.         newProc3:                UniversalProcPtr;
  738.         newProc4:                UniversalProcPtr;
  739.         newProc5:                UniversalProcPtr;
  740.         newProc6:                UniversalProcPtr;
  741.     END;
  742.     CQDProcsPtr = ^CQDProcs;
  743.  
  744.     CGrafPort = RECORD
  745.         device:                    INTEGER;
  746.         portPixMap:                PixMapHandle;                            {port's pixel map}
  747.         portVersion:            INTEGER;                                {high 2 bits always set}
  748.         grafVars:                Handle;                                    {Handle to more fields}
  749.         chExtra:                INTEGER;                                {character extra}
  750.         pnLocHFrac:                INTEGER;                                {pen fraction}
  751.         portRect:                Rect;
  752.         visRgn:                    RgnHandle;
  753.         clipRgn:                RgnHandle;
  754.         bkPixPat:                PixPatHandle;                            {background pattern}
  755.         rgbFgColor:                RGBColor;                                {RGB components of fg}
  756.         rgbBkColor:                RGBColor;                                {RGB components of bk}
  757.         pnLoc:                    Point;
  758.         pnSize:                    Point;
  759.         pnMode:                    INTEGER;
  760.         pnPixPat:                PixPatHandle;                            {pen's pattern}
  761.         fillPixPat:                PixPatHandle;                            {fill pattern}
  762.         pnVis:                    INTEGER;
  763.         txFont:                    INTEGER;
  764.         txFace:                    Style;                                    {txFace is unpacked byte  push as short}
  765.         txMode:                    INTEGER;
  766.         txSize:                    INTEGER;
  767.         spExtra:                Fixed;
  768.         fgColor:                LONGINT;
  769.         bkColor:                LONGINT;
  770.         colrBit:                INTEGER;
  771.         patStretch:                INTEGER;
  772.         picSave:                Handle;
  773.         rgnSave:                Handle;
  774.         polySave:                Handle;
  775.         grafProcs:                CQDProcsPtr;
  776.     END;
  777.     CGrafPtr = ^CGrafPort;
  778.  
  779.     CWindowPtr = CGrafPtr;
  780.  
  781.     ReqListRec = RECORD
  782.         reqLSize:                INTEGER;                                {request list size}
  783.         reqLData:                ARRAY [0..0] OF INTEGER;                {request list data}
  784.     END;
  785.     OpenCPicParams = RECORD
  786.         srcRect:                Rect;
  787.         hRes:                    Fixed;
  788.         vRes:                    Fixed;
  789.         version:                INTEGER;
  790.         reserved1:                INTEGER;
  791.         reserved2:                LONGINT;
  792.     END;
  793.     DeviceLoopDrawingProcPtr = ProcPtr;  { PROCEDURE DeviceLoopDrawing(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT); }
  794.     DeviceLoopDrawingUPP = UniversalProcPtr;
  795.  
  796. CONST
  797.     uppDeviceLoopDrawingProcInfo = $00003E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param, 4 byte param); }
  798.  
  799. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  800.     {$IFC NOT GENERATINGCFM }
  801.     INLINE $2E9F;
  802.     {$ENDC}
  803.  
  804. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  805.     {$IFC NOT GENERATINGCFM}
  806.     INLINE $205F, $4E90;
  807.     {$ENDC}
  808.  
  809. TYPE
  810.     QDGlobals = RECORD
  811.         privates:                PACKED ARRAY [0..75] OF CHAR;
  812.         randSeed:                LONGINT;
  813.         screenBits:                BitMap;
  814.         arrow:                    Cursor;
  815.         dkGray:                    Pattern;
  816.         ltGray:                    Pattern;
  817.         gray:                    Pattern;
  818.         black:                    Pattern;
  819.         white:                    Pattern;
  820.         thePort:                GrafPtr;
  821.     END;
  822.  
  823. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  824. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  825. VAR
  826.     {$PUSH}
  827.     {$J+}
  828.     qd: QDGlobals;
  829.     {$POP}
  830.  
  831. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  832.     {$IFC NOT GENERATINGCFM}
  833.     INLINE $A86E;
  834.     {$ENDC}
  835. PROCEDURE OpenPort(port: GrafPtr);
  836.     {$IFC NOT GENERATINGCFM}
  837.     INLINE $A86F;
  838.     {$ENDC}
  839. PROCEDURE InitPort(port: GrafPtr);
  840.     {$IFC NOT GENERATINGCFM}
  841.     INLINE $A86D;
  842.     {$ENDC}
  843. PROCEDURE ClosePort(port: GrafPtr);
  844.     {$IFC NOT GENERATINGCFM}
  845.     INLINE $A87D;
  846.     {$ENDC}
  847. PROCEDURE SetPort(port: GrafPtr);
  848.     {$IFC NOT GENERATINGCFM}
  849.     INLINE $A873;
  850.     {$ENDC}
  851. PROCEDURE GetPort(VAR port: GrafPtr);
  852.     {$IFC NOT GENERATINGCFM}
  853.     INLINE $A874;
  854.     {$ENDC}
  855. PROCEDURE GrafDevice(device: INTEGER);
  856.     {$IFC NOT GENERATINGCFM}
  857.     INLINE $A872;
  858.     {$ENDC}
  859. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  860.     {$IFC NOT GENERATINGCFM}
  861.     INLINE $A875;
  862.     {$ENDC}
  863. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  864.     {$IFC NOT GENERATINGCFM}
  865.     INLINE $A876;
  866.     {$ENDC}
  867. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  868.     {$IFC NOT GENERATINGCFM}
  869.     INLINE $A877;
  870.     {$ENDC}
  871. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  872.     {$IFC NOT GENERATINGCFM}
  873.     INLINE $A878;
  874.     {$ENDC}
  875. PROCEDURE SetClip(rgn: RgnHandle);
  876.     {$IFC NOT GENERATINGCFM}
  877.     INLINE $A879;
  878.     {$ENDC}
  879. PROCEDURE GetClip(rgn: RgnHandle);
  880.     {$IFC NOT GENERATINGCFM}
  881.     INLINE $A87A;
  882.     {$ENDC}
  883. PROCEDURE ClipRect({CONST}VAR r: Rect);
  884.     {$IFC NOT GENERATINGCFM}
  885.     INLINE $A87B;
  886.     {$ENDC}
  887. PROCEDURE BackPat(pat: ConstPatternParam);
  888.     {$IFC NOT GENERATINGCFM}
  889.     INLINE $A87C;
  890.     {$ENDC}
  891. PROCEDURE InitCursor;
  892.     {$IFC NOT GENERATINGCFM}
  893.     INLINE $A850;
  894.     {$ENDC}
  895. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  896.     {$IFC NOT GENERATINGCFM}
  897.     INLINE $A851;
  898.     {$ENDC}
  899. PROCEDURE HideCursor;
  900.     {$IFC NOT GENERATINGCFM}
  901.     INLINE $A852;
  902.     {$ENDC}
  903. PROCEDURE ShowCursor;
  904.     {$IFC NOT GENERATINGCFM}
  905.     INLINE $A853;
  906.     {$ENDC}
  907. PROCEDURE ObscureCursor;
  908.     {$IFC NOT GENERATINGCFM}
  909.     INLINE $A856;
  910.     {$ENDC}
  911. PROCEDURE HidePen;
  912.     {$IFC NOT GENERATINGCFM}
  913.     INLINE $A896;
  914.     {$ENDC}
  915. PROCEDURE ShowPen;
  916.     {$IFC NOT GENERATINGCFM}
  917.     INLINE $A897;
  918.     {$ENDC}
  919. PROCEDURE GetPen(VAR pt: Point);
  920.     {$IFC NOT GENERATINGCFM}
  921.     INLINE $A89A;
  922.     {$ENDC}
  923. PROCEDURE GetPenState(VAR pnState: PenState);
  924.     {$IFC NOT GENERATINGCFM}
  925.     INLINE $A898;
  926.     {$ENDC}
  927. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  928.     {$IFC NOT GENERATINGCFM}
  929.     INLINE $A899;
  930.     {$ENDC}
  931. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  932.     {$IFC NOT GENERATINGCFM}
  933.     INLINE $A89B;
  934.     {$ENDC}
  935. PROCEDURE PenMode(mode: INTEGER);
  936.     {$IFC NOT GENERATINGCFM}
  937.     INLINE $A89C;
  938.     {$ENDC}
  939. PROCEDURE PenPat(pat: ConstPatternParam);
  940.     {$IFC NOT GENERATINGCFM}
  941.     INLINE $A89D;
  942.     {$ENDC}
  943. PROCEDURE PenNormal;
  944.     {$IFC NOT GENERATINGCFM}
  945.     INLINE $A89E;
  946.     {$ENDC}
  947. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  948.     {$IFC NOT GENERATINGCFM}
  949.     INLINE $A893;
  950.     {$ENDC}
  951. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  952.     {$IFC NOT GENERATINGCFM}
  953.     INLINE $A894;
  954.     {$ENDC}
  955. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  956.     {$IFC NOT GENERATINGCFM}
  957.     INLINE $A891;
  958.     {$ENDC}
  959. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  960.     {$IFC NOT GENERATINGCFM}
  961.     INLINE $A892;
  962.     {$ENDC}
  963. PROCEDURE ForeColor(color: LONGINT);
  964.     {$IFC NOT GENERATINGCFM}
  965.     INLINE $A862;
  966.     {$ENDC}
  967. PROCEDURE BackColor(color: LONGINT);
  968.     {$IFC NOT GENERATINGCFM}
  969.     INLINE $A863;
  970.     {$ENDC}
  971. PROCEDURE ColorBit(whichBit: INTEGER);
  972.     {$IFC NOT GENERATINGCFM}
  973.     INLINE $A864;
  974.     {$ENDC}
  975. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  976.     {$IFC NOT GENERATINGCFM}
  977.     INLINE $A8A7;
  978.     {$ENDC}
  979. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  980.     {$IFC NOT GENERATINGCFM}
  981.     INLINE $A8A8;
  982.     {$ENDC}
  983. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  984.     {$IFC NOT GENERATINGCFM}
  985.     INLINE $A8A9;
  986.     {$ENDC}
  987. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  988.     {$IFC NOT GENERATINGCFM}
  989.     INLINE $A8AA;
  990.     {$ENDC}
  991. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  992.     {$IFC NOT GENERATINGCFM}
  993.     INLINE $A8AB;
  994.     {$ENDC}
  995. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  996.     {$IFC NOT GENERATINGCFM}
  997.     INLINE $A8A6;
  998.     {$ENDC}
  999. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1000.     {$IFC NOT GENERATINGCFM}
  1001.     INLINE $A8AE;
  1002.     {$ENDC}
  1003. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1004.     {$IFC NOT GENERATINGCFM}
  1005.     INLINE $A8A1;
  1006.     {$ENDC}
  1007. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1008.     {$IFC NOT GENERATINGCFM}
  1009.     INLINE $A8A2;
  1010.     {$ENDC}
  1011. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1012.     {$IFC NOT GENERATINGCFM}
  1013.     INLINE $A8A3;
  1014.     {$ENDC}
  1015. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1016.     {$IFC NOT GENERATINGCFM}
  1017.     INLINE $A8A4;
  1018.     {$ENDC}
  1019. PROCEDURE FillRect({CONST}VAR r: Rect; pat: ConstPatternParam);
  1020.     {$IFC NOT GENERATINGCFM}
  1021.     INLINE $A8A5;
  1022.     {$ENDC}
  1023. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1024.     {$IFC NOT GENERATINGCFM}
  1025.     INLINE $A8B7;
  1026.     {$ENDC}
  1027. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1028.     {$IFC NOT GENERATINGCFM}
  1029.     INLINE $A8B8;
  1030.     {$ENDC}
  1031. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1032.     {$IFC NOT GENERATINGCFM}
  1033.     INLINE $A8B9;
  1034.     {$ENDC}
  1035. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1036.     {$IFC NOT GENERATINGCFM}
  1037.     INLINE $A8BA;
  1038.     {$ENDC}
  1039. PROCEDURE FillOval({CONST}VAR r: Rect; pat: ConstPatternParam);
  1040.     {$IFC NOT GENERATINGCFM}
  1041.     INLINE $A8BB;
  1042.     {$ENDC}
  1043. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1044.     {$IFC NOT GENERATINGCFM}
  1045.     INLINE $A8B0;
  1046.     {$ENDC}
  1047. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1048.     {$IFC NOT GENERATINGCFM}
  1049.     INLINE $A8B1;
  1050.     {$ENDC}
  1051. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1052.     {$IFC NOT GENERATINGCFM}
  1053.     INLINE $A8B2;
  1054.     {$ENDC}
  1055. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1056.     {$IFC NOT GENERATINGCFM}
  1057.     INLINE $A8B3;
  1058.     {$ENDC}
  1059. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pat: ConstPatternParam);
  1060.     {$IFC NOT GENERATINGCFM}
  1061.     INLINE $A8B4;
  1062.     {$ENDC}
  1063. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1064.     {$IFC NOT GENERATINGCFM}
  1065.     INLINE $A8BE;
  1066.     {$ENDC}
  1067. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1068.     {$IFC NOT GENERATINGCFM}
  1069.     INLINE $A8BF;
  1070.     {$ENDC}
  1071. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1072.     {$IFC NOT GENERATINGCFM}
  1073.     INLINE $A8C0;
  1074.     {$ENDC}
  1075. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1076.     {$IFC NOT GENERATINGCFM}
  1077.     INLINE $A8C1;
  1078.     {$ENDC}
  1079. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pat: ConstPatternParam);
  1080.     {$IFC NOT GENERATINGCFM}
  1081.     INLINE $A8C2;
  1082.     {$ENDC}
  1083. FUNCTION NewRgn: RgnHandle;
  1084.     {$IFC NOT GENERATINGCFM}
  1085.     INLINE $A8D8;
  1086.     {$ENDC}
  1087. PROCEDURE OpenRgn;
  1088.     {$IFC NOT GENERATINGCFM}
  1089.     INLINE $A8DA;
  1090.     {$ENDC}
  1091. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1092.     {$IFC NOT GENERATINGCFM}
  1093.     INLINE $A8DB;
  1094.     {$ENDC}
  1095. {$IFC NOT SystemSevenOrLater }
  1096. FUNCTION BitMapToRegionGlue(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1097. {$ENDC}
  1098. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1099.     {$IFC NOT GENERATINGCFM}
  1100.     INLINE $A8D7;
  1101.     {$ENDC}
  1102. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1103.     {$IFC NOT GENERATINGCFM}
  1104.     INLINE $A8D9;
  1105.     {$ENDC}
  1106. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1107.     {$IFC NOT GENERATINGCFM}
  1108.     INLINE $A8DC;
  1109.     {$ENDC}
  1110. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1111.     {$IFC NOT GENERATINGCFM}
  1112.     INLINE $A8DD;
  1113.     {$ENDC}
  1114. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1115.     {$IFC NOT GENERATINGCFM}
  1116.     INLINE $A8DE;
  1117.     {$ENDC}
  1118. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1119.     {$IFC NOT GENERATINGCFM}
  1120.     INLINE $A8DF;
  1121.     {$ENDC}
  1122. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1123.     {$IFC NOT GENERATINGCFM}
  1124.     INLINE $A8E0;
  1125.     {$ENDC}
  1126. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1127.     {$IFC NOT GENERATINGCFM}
  1128.     INLINE $A8E1;
  1129.     {$ENDC}
  1130. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1131.     {$IFC NOT GENERATINGCFM}
  1132.     INLINE $A8E4;
  1133.     {$ENDC}
  1134. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1135.     {$IFC NOT GENERATINGCFM}
  1136.     INLINE $A8E5;
  1137.     {$ENDC}
  1138. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1139.     {$IFC NOT GENERATINGCFM}
  1140.     INLINE $A8E6;
  1141.     {$ENDC}
  1142. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1143.     {$IFC NOT GENERATINGCFM}
  1144.     INLINE $A8E7;
  1145.     {$ENDC}
  1146. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1147.     {$IFC NOT GENERATINGCFM}
  1148.     INLINE $A8E9;
  1149.     {$ENDC}
  1150. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1151.     {$IFC NOT GENERATINGCFM}
  1152.     INLINE $A8E3;
  1153.     {$ENDC}
  1154. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1155.     {$IFC NOT GENERATINGCFM}
  1156.     INLINE $A8E2;
  1157.     {$ENDC}
  1158. PROCEDURE FrameRgn(rgn: RgnHandle);
  1159.     {$IFC NOT GENERATINGCFM}
  1160.     INLINE $A8D2;
  1161.     {$ENDC}
  1162. PROCEDURE PaintRgn(rgn: RgnHandle);
  1163.     {$IFC NOT GENERATINGCFM}
  1164.     INLINE $A8D3;
  1165.     {$ENDC}
  1166. PROCEDURE EraseRgn(rgn: RgnHandle);
  1167.     {$IFC NOT GENERATINGCFM}
  1168.     INLINE $A8D4;
  1169.     {$ENDC}
  1170. PROCEDURE InvertRgn(rgn: RgnHandle);
  1171.     {$IFC NOT GENERATINGCFM}
  1172.     INLINE $A8D5;
  1173.     {$ENDC}
  1174. PROCEDURE FillRgn(rgn: RgnHandle; pat: ConstPatternParam);
  1175.     {$IFC NOT GENERATINGCFM}
  1176.     INLINE $A8D6;
  1177.     {$ENDC}
  1178. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1179.     {$IFC NOT GENERATINGCFM}
  1180.     INLINE $A8EF;
  1181.     {$ENDC}
  1182. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1183.     {$IFC NOT GENERATINGCFM}
  1184.     INLINE $A8EC;
  1185.     {$ENDC}
  1186. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1187.     {$IFC NOT GENERATINGCFM}
  1188.     INLINE $A839;
  1189.     {$ENDC}
  1190. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1191.     {$IFC NOT GENERATINGCFM}
  1192.     INLINE $A838;
  1193.     {$ENDC}
  1194. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1195.     {$IFC NOT GENERATINGCFM}
  1196.     INLINE $A817;
  1197.     {$ENDC}
  1198. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1199.     {$IFC NOT GENERATINGCFM}
  1200.     INLINE $A8F3;
  1201.     {$ENDC}
  1202. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1203.     {$IFC NOT GENERATINGCFM}
  1204.     INLINE $A8F2;
  1205.     {$ENDC}
  1206. PROCEDURE ClosePicture;
  1207.     {$IFC NOT GENERATINGCFM}
  1208.     INLINE $A8F4;
  1209.     {$ENDC}
  1210. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1211.     {$IFC NOT GENERATINGCFM}
  1212.     INLINE $A8F6;
  1213.     {$ENDC}
  1214. PROCEDURE KillPicture(myPicture: PicHandle);
  1215.     {$IFC NOT GENERATINGCFM}
  1216.     INLINE $A8F5;
  1217.     {$ENDC}
  1218. FUNCTION OpenPoly: PolyHandle;
  1219.     {$IFC NOT GENERATINGCFM}
  1220.     INLINE $A8CB;
  1221.     {$ENDC}
  1222. PROCEDURE ClosePoly;
  1223.     {$IFC NOT GENERATINGCFM}
  1224.     INLINE $A8CC;
  1225.     {$ENDC}
  1226. PROCEDURE KillPoly(poly: PolyHandle);
  1227.     {$IFC NOT GENERATINGCFM}
  1228.     INLINE $A8CD;
  1229.     {$ENDC}
  1230. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1231.     {$IFC NOT GENERATINGCFM}
  1232.     INLINE $A8CE;
  1233.     {$ENDC}
  1234. PROCEDURE FramePoly(poly: PolyHandle);
  1235.     {$IFC NOT GENERATINGCFM}
  1236.     INLINE $A8C6;
  1237.     {$ENDC}
  1238. PROCEDURE PaintPoly(poly: PolyHandle);
  1239.     {$IFC NOT GENERATINGCFM}
  1240.     INLINE $A8C7;
  1241.     {$ENDC}
  1242. PROCEDURE ErasePoly(poly: PolyHandle);
  1243.     {$IFC NOT GENERATINGCFM}
  1244.     INLINE $A8C8;
  1245.     {$ENDC}
  1246. PROCEDURE InvertPoly(poly: PolyHandle);
  1247.     {$IFC NOT GENERATINGCFM}
  1248.     INLINE $A8C9;
  1249.     {$ENDC}
  1250. PROCEDURE FillPoly(poly: PolyHandle; pat: ConstPatternParam);
  1251.     {$IFC NOT GENERATINGCFM}
  1252.     INLINE $A8CA;
  1253.     {$ENDC}
  1254. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1255.     {$IFC NOT GENERATINGCFM}
  1256.     INLINE $A880;
  1257.     {$ENDC}
  1258. PROCEDURE LocalToGlobal(VAR pt: Point);
  1259.     {$IFC NOT GENERATINGCFM}
  1260.     INLINE $A870;
  1261.     {$ENDC}
  1262. PROCEDURE GlobalToLocal(VAR pt: Point);
  1263.     {$IFC NOT GENERATINGCFM}
  1264.     INLINE $A871;
  1265.     {$ENDC}
  1266. FUNCTION Random: INTEGER;
  1267.     {$IFC NOT GENERATINGCFM}
  1268.     INLINE $A861;
  1269.     {$ENDC}
  1270. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: ConstStr255Param);
  1271.     {$IFC NOT GENERATINGCFM}
  1272.     INLINE $A866;
  1273.     {$ENDC}
  1274. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1275.     {$IFC NOT GENERATINGCFM}
  1276.     INLINE $A865;
  1277.     {$ENDC}
  1278. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1279.     {$IFC NOT GENERATINGCFM}
  1280.     INLINE $A8F8;
  1281.     {$ENDC}
  1282. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1283.     {$IFC NOT GENERATINGCFM}
  1284.     INLINE $A8F9;
  1285.     {$ENDC}
  1286. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1287.     {$IFC NOT GENERATINGCFM}
  1288.     INLINE $A8FA;
  1289.     {$ENDC}
  1290. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1291.     {$IFC NOT GENERATINGCFM}
  1292.     INLINE $A8FB;
  1293.     {$ENDC}
  1294. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1295.     {$IFC NOT GENERATINGCFM}
  1296.     INLINE $A8FC;
  1297.     {$ENDC}
  1298. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1299.     {$IFC NOT GENERATINGCFM}
  1300.     INLINE $A8EA;
  1301.     {$ENDC}
  1302. PROCEDURE StdRect(verb: ByteParameter; {CONST}VAR r: Rect);
  1303.     {$IFC NOT GENERATINGCFM}
  1304.     INLINE $A8A0;
  1305.     {$ENDC}
  1306. PROCEDURE StdRRect(verb: ByteParameter; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1307.     {$IFC NOT GENERATINGCFM}
  1308.     INLINE $A8AF;
  1309.     {$ENDC}
  1310. PROCEDURE StdOval(verb: ByteParameter; {CONST}VAR r: Rect);
  1311.     {$IFC NOT GENERATINGCFM}
  1312.     INLINE $A8B6;
  1313.     {$ENDC}
  1314. PROCEDURE StdArc(verb: ByteParameter; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1315.     {$IFC NOT GENERATINGCFM}
  1316.     INLINE $A8BD;
  1317.     {$ENDC}
  1318. PROCEDURE StdPoly(verb: ByteParameter; poly: PolyHandle);
  1319.     {$IFC NOT GENERATINGCFM}
  1320.     INLINE $A8C5;
  1321.     {$ENDC}
  1322. PROCEDURE StdRgn(verb: ByteParameter; rgn: RgnHandle);
  1323.     {$IFC NOT GENERATINGCFM}
  1324.     INLINE $A8D1;
  1325.     {$ENDC}
  1326. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1327.     {$IFC NOT GENERATINGCFM}
  1328.     INLINE $A8EB;
  1329.     {$ENDC}
  1330. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1331.     {$IFC NOT GENERATINGCFM}
  1332.     INLINE $A8F1;
  1333.     {$ENDC}
  1334. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1335.     {$IFC NOT GENERATINGCFM}
  1336.     INLINE $A8EE;
  1337.     {$ENDC}
  1338. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1339.     {$IFC NOT GENERATINGCFM}
  1340.     INLINE $A8F0;
  1341.     {$ENDC}
  1342. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1343.     {$IFC NOT GENERATINGCFM}
  1344.     INLINE $A87E;
  1345.     {$ENDC}
  1346. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1347.     {$IFC NOT GENERATINGCFM}
  1348.     INLINE $A881;
  1349.     {$ENDC}
  1350. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1351.     {$IFC NOT GENERATINGCFM}
  1352.     INLINE $A8AD;
  1353.     {$ENDC}
  1354. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1355.     {$IFC NOT GENERATINGCFM}
  1356.     INLINE $A8AC;
  1357.     {$ENDC}
  1358. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1359.     {$IFC NOT GENERATINGCFM}
  1360.     INLINE $A8C3;
  1361.     {$ENDC}
  1362. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1363.     {$IFC NOT GENERATINGCFM}
  1364.     INLINE $A87F;
  1365.     {$ENDC}
  1366. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1367.     {$IFC NOT GENERATINGCFM}
  1368.     INLINE $A8E8;
  1369.     {$ENDC}
  1370. PROCEDURE StdLine(newPt: Point);
  1371.     {$IFC NOT GENERATINGCFM}
  1372.     INLINE $A890;
  1373.     {$ENDC}
  1374. PROCEDURE OpenCPort(port: CGrafPtr);
  1375.     {$IFC NOT GENERATINGCFM}
  1376.     INLINE $AA00;
  1377.     {$ENDC}
  1378. PROCEDURE InitCPort(port: CGrafPtr);
  1379.     {$IFC NOT GENERATINGCFM}
  1380.     INLINE $AA01;
  1381.     {$ENDC}
  1382. PROCEDURE CloseCPort(port: CGrafPtr);
  1383.     {$IFC NOT GENERATINGCFM}
  1384.     INLINE $A87D;
  1385.     {$ENDC}
  1386. FUNCTION NewPixMap: PixMapHandle;
  1387.     {$IFC NOT GENERATINGCFM}
  1388.     INLINE $AA03;
  1389.     {$ENDC}
  1390. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1391.     {$IFC NOT GENERATINGCFM}
  1392.     INLINE $AA04;
  1393.     {$ENDC}
  1394. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1395.     {$IFC NOT GENERATINGCFM}
  1396.     INLINE $AA05;
  1397.     {$ENDC}
  1398. FUNCTION NewPixPat: PixPatHandle;
  1399.     {$IFC NOT GENERATINGCFM}
  1400.     INLINE $AA07;
  1401.     {$ENDC}
  1402. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1403.     {$IFC NOT GENERATINGCFM}
  1404.     INLINE $AA08;
  1405.     {$ENDC}
  1406. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1407.     {$IFC NOT GENERATINGCFM}
  1408.     INLINE $AA09;
  1409.     {$ENDC}
  1410. PROCEDURE PenPixPat(pp: PixPatHandle);
  1411.     {$IFC NOT GENERATINGCFM}
  1412.     INLINE $AA0A;
  1413.     {$ENDC}
  1414. PROCEDURE BackPixPat(pp: PixPatHandle);
  1415.     {$IFC NOT GENERATINGCFM}
  1416.     INLINE $AA0B;
  1417.     {$ENDC}
  1418. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1419.     {$IFC NOT GENERATINGCFM}
  1420.     INLINE $AA0C;
  1421.     {$ENDC}
  1422. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1423.     {$IFC NOT GENERATINGCFM}
  1424.     INLINE $AA0D;
  1425.     {$ENDC}
  1426. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1427.     {$IFC NOT GENERATINGCFM}
  1428.     INLINE $AA0E;
  1429.     {$ENDC}
  1430. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1431.     {$IFC NOT GENERATINGCFM}
  1432.     INLINE $AA0F;
  1433.     {$ENDC}
  1434. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1435.     {$IFC NOT GENERATINGCFM}
  1436.     INLINE $AA10;
  1437.     {$ENDC}
  1438. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1439.     {$IFC NOT GENERATINGCFM}
  1440.     INLINE $AA11;
  1441.     {$ENDC}
  1442. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1443.     {$IFC NOT GENERATINGCFM}
  1444.     INLINE $AA12;
  1445.     {$ENDC}
  1446. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1447.     {$IFC NOT GENERATINGCFM}
  1448.     INLINE $AA13;
  1449.     {$ENDC}
  1450. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1451.     {$IFC NOT GENERATINGCFM}
  1452.     INLINE $AA14;
  1453.     {$ENDC}
  1454. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1455.     {$IFC NOT GENERATINGCFM}
  1456.     INLINE $AA15;
  1457.     {$ENDC}
  1458. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1459.     {$IFC NOT GENERATINGCFM}
  1460.     INLINE $AA16;
  1461.     {$ENDC}
  1462. PROCEDURE SetPortPix(pm: PixMapHandle);
  1463.     {$IFC NOT GENERATINGCFM}
  1464.     INLINE $AA06;
  1465.     {$ENDC}
  1466. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1467.     {$IFC NOT GENERATINGCFM}
  1468.     INLINE $AA17;
  1469.     {$ENDC}
  1470. PROCEDURE GetForeColor(VAR color: RGBColor);
  1471.     {$IFC NOT GENERATINGCFM}
  1472.     INLINE $AA19;
  1473.     {$ENDC}
  1474. PROCEDURE GetBackColor(VAR color: RGBColor);
  1475.     {$IFC NOT GENERATINGCFM}
  1476.     INLINE $AA1A;
  1477.     {$ENDC}
  1478. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1479.     {$IFC NOT GENERATINGCFM}
  1480.     INLINE $AA50;
  1481.     {$ENDC}
  1482. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1483.     {$IFC NOT GENERATINGCFM}
  1484.     INLINE $AA4F;
  1485.     {$ENDC}
  1486. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1487.     {$IFC NOT GENERATINGCFM}
  1488.     INLINE $AA20;
  1489.     {$ENDC}
  1490. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1491.     {$IFC NOT GENERATINGCFM}
  1492.     INLINE $AA21;
  1493.     {$ENDC}
  1494. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1495.     {$IFC NOT GENERATINGCFM}
  1496.     INLINE $AA22;
  1497.     {$ENDC}
  1498. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1499.     {$IFC NOT GENERATINGCFM}
  1500.     INLINE $AA24;
  1501.     {$ENDC}
  1502. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1503.     {$IFC NOT GENERATINGCFM}
  1504.     INLINE $AA18;
  1505.     {$ENDC}
  1506. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1507.     {$IFC NOT GENERATINGCFM}
  1508.     INLINE $AA1B;
  1509.     {$ENDC}
  1510. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1511.     {$IFC NOT GENERATINGCFM}
  1512.     INLINE $AA1C;
  1513.     {$ENDC}
  1514. PROCEDURE AllocCursor;
  1515.     {$IFC NOT GENERATINGCFM}
  1516.     INLINE $AA1D;
  1517.     {$ENDC}
  1518. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1519.     {$IFC NOT GENERATINGCFM}
  1520.     INLINE $AA26;
  1521.     {$ENDC}
  1522. {$IFC OLDROUTINELOCATIONS }
  1523. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1524.     {$IFC NOT GENERATINGCFM}
  1525.     INLINE $AA1E;
  1526.     {$ENDC}
  1527. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1528.     {$IFC NOT GENERATINGCFM}
  1529.     INLINE $AA1F;
  1530.     {$ENDC}
  1531. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1532.     {$IFC NOT GENERATINGCFM}
  1533.     INLINE $AA25;
  1534.     {$ENDC}
  1535. {$ENDC}
  1536. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1537.     {$IFC NOT GENERATINGCFM}
  1538.     INLINE $AA4E;
  1539.     {$ENDC}
  1540. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1541.     {$IFC NOT GENERATINGCFM}
  1542.     INLINE $AA27;
  1543.     {$ENDC}
  1544. FUNCTION GetCTSeed: LONGINT;
  1545.     {$IFC NOT GENERATINGCFM}
  1546.     INLINE $AA28;
  1547.     {$ENDC}
  1548. FUNCTION GetDeviceList: GDHandle;
  1549.     {$IFC NOT GENERATINGCFM}
  1550.     INLINE $AA29;
  1551.     {$ENDC}
  1552. FUNCTION GetMainDevice: GDHandle;
  1553.     {$IFC NOT GENERATINGCFM}
  1554.     INLINE $AA2A;
  1555.     {$ENDC}
  1556. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1557.     {$IFC NOT GENERATINGCFM}
  1558.     INLINE $AA2B;
  1559.     {$ENDC}
  1560. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1561.     {$IFC NOT GENERATINGCFM}
  1562.     INLINE $AA2C;
  1563.     {$ENDC}
  1564. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1565.     {$IFC NOT GENERATINGCFM}
  1566.     INLINE $AA2D;
  1567.     {$ENDC}
  1568. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1569.     {$IFC NOT GENERATINGCFM}
  1570.     INLINE $AA2E;
  1571.     {$ENDC}
  1572. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1573.     {$IFC NOT GENERATINGCFM}
  1574.     INLINE $AA2F;
  1575.     {$ENDC}
  1576. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1577.     {$IFC NOT GENERATINGCFM}
  1578.     INLINE $AA30;
  1579.     {$ENDC}
  1580. PROCEDURE SetGDevice(gd: GDHandle);
  1581.     {$IFC NOT GENERATINGCFM}
  1582.     INLINE $AA31;
  1583.     {$ENDC}
  1584. FUNCTION GetGDevice: GDHandle;
  1585.     {$IFC NOT GENERATINGCFM}
  1586.     INLINE $AA32;
  1587.     {$ENDC}
  1588. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1589.     {$IFC NOT GENERATINGCFM}
  1590.     INLINE $AA33;
  1591.     {$ENDC}
  1592. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1593.     {$IFC NOT GENERATINGCFM}
  1594.     INLINE $AA34;
  1595.     {$ENDC}
  1596. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1597.     {$IFC NOT GENERATINGCFM}
  1598.     INLINE $AA35;
  1599.     {$ENDC}
  1600. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1601.     {$IFC NOT GENERATINGCFM}
  1602.     INLINE $AA36;
  1603.     {$ENDC}
  1604. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1605.     {$IFC NOT GENERATINGCFM}
  1606.     INLINE $AA37;
  1607.     {$ENDC}
  1608. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1609.     {$IFC NOT GENERATINGCFM}
  1610.     INLINE $AA39;
  1611.     {$ENDC}
  1612. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1613.     {$IFC NOT GENERATINGCFM}
  1614.     INLINE $AA3A;
  1615.     {$ENDC}
  1616. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1617.     {$IFC NOT GENERATINGCFM}
  1618.     INLINE $AA3B;
  1619.     {$ENDC}
  1620. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1621.     {$IFC NOT GENERATINGCFM}
  1622.     INLINE $AA4C;
  1623.     {$ENDC}
  1624. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1625.     {$IFC NOT GENERATINGCFM}
  1626.     INLINE $AA4D;
  1627.     {$ENDC}
  1628. PROCEDURE SetClientID(id: INTEGER);
  1629.     {$IFC NOT GENERATINGCFM}
  1630.     INLINE $AA3C;
  1631.     {$ENDC}
  1632. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1633.     {$IFC NOT GENERATINGCFM}
  1634.     INLINE $AA3D;
  1635.     {$ENDC}
  1636. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1637.     {$IFC NOT GENERATINGCFM}
  1638.     INLINE $AA3E;
  1639.     {$ENDC}
  1640. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1641.     {$IFC NOT GENERATINGCFM}
  1642.     INLINE $AA3F;
  1643.     {$ENDC}
  1644. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1645.     {$IFC NOT GENERATINGCFM}
  1646.     INLINE $AA49;
  1647.     {$ENDC}
  1648. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1649.     {$IFC NOT GENERATINGCFM}
  1650.     INLINE $AA4A;
  1651.     {$ENDC}
  1652. FUNCTION QDError: INTEGER;
  1653.     {$IFC NOT GENERATINGCFM}
  1654.     INLINE $AA40;
  1655.     {$ENDC}
  1656. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1657.     {$IFC NOT GENERATINGCFM}
  1658.     INLINE $AA51;
  1659.     {$ENDC}
  1660. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1661.     {$IFC NOT GENERATINGCFM}
  1662.     INLINE $ABCA;
  1663.     {$ENDC}
  1664. FUNCTION GetMaskTable: Ptr;
  1665.     {$IFC NOT GENERATINGCFM}
  1666.     INLINE $A836, $2E88;
  1667.     {$ENDC}
  1668. {$IFC OLDROUTINENAMES }
  1669. PROCEDURE DisposPixMap(pm: PixMapHandle);
  1670.     {$IFC NOT GENERATINGCFM}
  1671.     INLINE $AA04;
  1672.     {$ENDC}
  1673. PROCEDURE DisposPixPat(pp: PixPatHandle);
  1674.     {$IFC NOT GENERATINGCFM}
  1675.     INLINE $AA08;
  1676.     {$ENDC}
  1677. PROCEDURE DisposCTable(cTable: CTabHandle);
  1678.     {$IFC NOT GENERATINGCFM}
  1679.     INLINE $AA24;
  1680.     {$ENDC}
  1681. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  1682.     {$IFC NOT GENERATINGCFM}
  1683.     INLINE $AA26;
  1684.     {$ENDC}
  1685. {$IFC OLDROUTINELOCATIONS }
  1686. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  1687.     {$IFC NOT GENERATINGCFM}
  1688.     INLINE $AA25;
  1689.     {$ENDC}
  1690. {$ENDC}
  1691. PROCEDURE DisposGDevice(gdh: GDHandle);
  1692.     {$IFC NOT GENERATINGCFM}
  1693.     INLINE $AA30;
  1694.     {$ENDC}
  1695. {$ENDC}
  1696.  
  1697. {$ALIGN RESET}
  1698. {$POP}
  1699.  
  1700. {$SETC UsingIncludes := QuickdrawIncludes}
  1701.  
  1702. {$ENDC} {__QUICKDRAW__}
  1703.  
  1704. {$IFC NOT UsingIncludes}
  1705.  END.
  1706. {$ENDC}
  1707.